\section{Setup do ambiente}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Setup do JBoss}

\begin{frame}
  \frametitle{Configuração do JBoss}
  \begin{itemize}
    \item Para instalar o JBoss, basta extrair o arquivo zip
    \item No eclipse, vá em $Window\rightarrow Show~View\rightarrow Servers$
    \item Na aba $Servers$, clique com o botão direito, vá em
    $new\rightarrow Server$. Escolha $JBoss$ e clique em $Next$. Em
    $Application~Server~Directory$ informe o diretório onde o JBoss foi
    extraído. Clique em $Finish$
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Criação do projeto Web}
  \begin{itemize}
    \item Para criar um projeto Web, no $Package~Explorer$ clique com o botão
    direito, vá em $new\rightarrow Project\ldots$. Em $Web$, escolha
    $Dynamic~Web~Project$ e clique em $Next$. Dê um nome ao projeto, escolha o
    JBoss como runtime e JavaServerFaces $1.2$ em $Configuration$. Vá até o
    final do wizard e clique em $Finish$
    \item Em $WebContent$, crie um arquivo de testes ($new\rightarrow
    file$ com nome de $hello.txt$)
    \item Na aba $Servers$, clique com o botão direito no servidor e vá em $Add
    ~and~Remove$. Selecione o projeto, clique em $Add$ e então em $Finish$
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Criação do projeto Web - Continuação}
  \begin{itemize}
    \item Dê dois cliques no servidor. Na aba $timeouts$, coloque $600$ para
    ambos os parâmetros. Feche a janela do servidor
    \item Na aba servers, clique em $Run$. Os logs do servidor são vistos na
    aba $Console$
    \item Aguarde a inicialização. A mensagem de sucesso é ``{\it JBoss
    (Microcontainer) \ldots Started in \ldots}''
    \item Inicie um browser, e teste a URL
    $http://localhost:8080/NomeDoProjeto/hello.txt$. Você deve visualizar o
    arquivo criado no projeto
  \end{itemize}
\end{frame}

\subsection{Aplicação Java Web}
\begin{frame}
  \frametitle{Deployment Descriptor: web.xml}
  \begin{itemize}
    \item O Eclipse gerou automaticamente o arquivo $web.xml$ no diretório
    ``WebContent/WEB-INF''. Na aba ``source'' vê-se o conteúdo do arquivo
    \item Nesse arquivo configura-se a aplicação e seus componentes
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Criando um Servlet}
  \begin{itemize}
    \item O servlet é a classe de ``nível mais baixo'' da plataforma Java para
    Web
    \item Implementa métodos que recebem uma $request$ HTTP e geram uma
    $response$ (ou redirecionam a outra resposta)
    \item Exercício: Crie o pacote $projeto.servlet$. Nesse pacote, crie um
    servlet clicando com o botão direito no pacote e selecionando
    $new\rightarrow Other\ldots$. Vá em $Web$ e escolha $Servlet$. Dê o nome de
    $TesteServlet$ e clique em $Finish$. É criado um servlet com esqueletos do
    construtor e dos métodos $doGet$ e $doPost$
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Definindo o servlet}
  \begin{itemize}
    \item O servlet criado deve ser definido e mapeado no $web.xml$ 
    \item O Eclipse já mapeou automaticamente. Verifique abrindo o arquivo
    \item Em $url-pattern$ tem-se o mapeamento do servlet. Para acessá-lo,
    utiliza-se a URL ``$http://localhost:8080/NomeDoProjeto/TesteServlet$''
  \end{itemize} 
\end{frame}

\begin{frame}
  \frametitle{Protocolo HTTP: Métodos GET e POST}
  \begin{itemize}
    \item Uma requisição do tipo $GET$ é geralmente utilizada quando se digita
    uma URL no browser, ou quando se clica em um um link
    \item Uma requisição do tipo $POST$ é geralmente utilizada quando se entram
    dados em um formulário e clica-se num botão para submeter
    \item No servlet, quando a requisição é feita os métodos $doGet$ ou
    $doPost$ são invocados
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Métodos de serviço}
  \begin{itemize}
    \item Os métodos do servlet devem processar a request, e então gerar uma
    saída ou direcionar para outra saída
    \item Os métodos recebem dois parâmetros: $request$ e $response$
	\begin{itemize}
	  \item $request$: Parâmetros de entrada enviados pelo usuário e escopo da
	  chamada
	  \item $response$: Resposta enviada ao usuário
	\end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Objeto Request}
  \begin{itemize}
    \item Na request estão os valores enviados pelo cliente:
    \begin{itemize}
      \item $getParameter$: Parâmetros
      \item $getHeader$: Headers HTTP
      \item $getCookies$: Cookies HTTP
    \end{itemize}
    \item Além disso, é pela request que se obtém a seção do usuário e se
    mantém os atributos de escopo de requisição (tópicos das próximas seções)
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Objeto Response}
  \begin{itemize}
    \item Na response são escritos os dados a serem retornados ao usuário 
    \item O conteúdo pode ser uma página HTML ou um arquivo binário para
    download
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Implementando-se o método doGet}
  \begin{itemize}
    \item Exercício: Implemente o método doGet para receber um nome da
    requisição e gerar uma resposta HTML com a mensagem ``Hello, nome!''
    \item Acesse a URL por:
    ``$http://localhost:8080/Teste/TesteServlet?name=Eduardo$''
  \end{itemize}
  \begin{verbatim}
  String name = request.getParameter("name");
  PrintWriter writer = response.getWriter();
  writer.print("<html><body><h1>");
  writer.print("Hello, " + name + "!");
  writer.print("</h1></body><html>");
  writer.close();
  response.flushBuffer();
  \end{verbatim}
\end{frame}

\begin{frame}
  \frametitle{Padrão de Projeto: MVC}
  \begin{itemize}
    \item No MVC, deve-se separar os componentes de {\it model}, {\it view} e
    {\it controller}:
    \begin{itemize}
      \item {\it model}: Modelo de dados (representação das entidades de
      negócio)
      \item {\it view}: Componentes de apresentação
      \item {\it controller}: Controle do fluxo do usuário
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{MVC na API de servlets}
  \begin{itemize}
    \item Pode-se implementar o MVC na API de servlets usando-se:
    \begin{itemize}
      \item {\it model}: JavaBeans
      \item {\it controller}: Servlets
      \item {\it view}: JSP's
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{MVC: Criando-se uma JSP}
  \begin{itemize}
    \item Em $WebContent$, vá em $new\rightarrow Other$, vá em
    $Web\rightarrow JSP$. Dê um nome e use o template de HTML. Clique em finish
    \item Dentro do $body$ da página, coloque:
    \begin{verbatim}
    <h1>Hello, ${requestScope.nomeUsuario}</h1>
    \end{verbatim}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{MVC: Alterando o Servlet}
  \begin{itemize}
    \item Remova o código atual do servlet e coloque:
    \begin{verbatim}
String name = request.getParameter("name");
request.setAttribute("nomeUsuario", name);
request.getRequestDispatcher("/teste.jsp")
           .forward(request, response);
    \end{verbatim}
    \item Esse código:
    \begin{itemize}
      \item Processa a entrada (em um caso mais complexo ele validaria as
      entradas e poderia acessar um banco de dados)
      \item Prepara as saídas para a página (em um caso mais complexo um
      javabean representaria as informações). $Controle$ e $View$ ``conversam''
      por meio de atributos
      \item Dispara o processamento para a JSP
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Padrão de Projeto: MVC}
  \begin{itemize}
    \item A maioria das telas das aplicações segue essa sequencia:
    \begin{itemize}
      \item Entrada do usuário $\rightarrow$ Controller $\rightarrow$ View
    \end{itemize}
    \item Isso ocorre independente do framework utilizado (JSF, Struts, ou
    servlets puros como foi o caso). As JSP's não devem ser acessadas
    diretamente
    \item Em alguns casos ainda é necessário escrever na $response$ como no
    primeiro exemplo. Por exemplo, para downloads de arquivos binários
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Implementando-se um POST}
  \begin{itemize}
    \item Implementando-se um fluxo de interação com usuário:
    \begin{itemize}
      \item O usuário requisita uma página por meio de um get (já implementado)
      \item Altere a JSP já criada, removendo o conteúdo atual e adicionando um
      form:
    \begin{verbatim}
<form action="/Teste/TesteServlet" method="post">
  <h3>Dados da pessoa:</h3>
  <h4 style="color:red;">${requestScope.mensagem}</h4>
  Nome: <input type="text" name="nome" /> <br/> 
  RG: <input type="text" name="rg" /> <br/>
  CHN: <input type="text" name="cnh" /> <br/>
  Idade: <input type="text" name="idade" /> <br/>
  <input type="submit" value="Cadastrar">
</form>
    \end{verbatim}
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Implementando-se um POST}
  \begin{itemize}
    \item Implementando-se um fluxo de interação com usuário:
    \begin{itemize}
      \item No método doPost do servlet, processamos as entradas do usuário:
    \begin{verbatim}
Pessoa pessoa = new Pessoa();
pessoa.setNome(request.getParameter("nome"));
pessoa.setRg(new Integer(request.getParameter("rg")));
pessoa.setCnh(new Integer(request.getParameter("cnh")));
pessoa.setIdade(new Integer(request.getParameter("idade")));
// TODO: Salvar a pessoa no banco
System.out.println("doPost:" + pessoa);
request.setAttribute("mensagem", 
                     "Pessa cadastrada com sucesso");
request.getRequestDispatcher("/teste.jsp")
            .forward(request, response);
    \end{verbatim}
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Sobre o form html}
  \begin{itemize}
    \item Em ``action'', colocamos o mapeamento do servlet para onde a
    requisição será enviada
    \item Em ``method'', colocamos o método que será utilizado para envio dos
    dados: $GET$ ou $POST$
    \begin{itemize}
      \item Os dados do form podem ser enviados por $GET$, mas eles ficam
      visíveis na URL
      \item O limite da request com $get$ é de $255$ caracteres
	\end{itemize} 
  \end{itemize}
\end{frame}
